// export default mfcHL

// function mfcHL(str) {
//   const f = str.split('\n')
//   let result = '<div>', r = 0, imp = false, e = f.length - 1
//   while (r <= f.length) {
//     let l = f[r++]
//     if (!imp && l && l[0] === '@') {
//       l = _processImport(l)
//     }
//     if (!l) {
//       result += '<br/><br/>'
//       continue
//     }
//     if (l[0] === '#' || l.startsWith('---')) {
//       result += wrap(l, 'x-mfc-sct')
//       continue
//     } else if (l[0] === ' ') {
//       result += wrap(l, 'x-mfc-ign')
//       continue
//     } else if (l[1] === '-' || l[1] === '+') {
//       result += wrap(l, 'x-mfc-err')
//       break
//     }
//     imp = true, _processLine(l)
//   }
//   return result + '</div>'


//   function wrap(str, className) {
//     return `<span class="${className}">${str}</span>`
//   }

//   function _processImport(_l) {
//     while (_l && _l[1] == '@' && r <= e) {
//       let fi = 0, _ori = _l, _l = f[r++]
//       result += wrap(l, 'x-mfc-imp')
//     }
//   }
//   function _processLine(_l) {

//   }

//   function _processValue(_l, _idx, _raw = false, _fi = [0]) {
//     let s = '';
//     const cs = Array.from(_l);
//     let inQ = false;
//     const q = this.q;

//     if (!_raw && cs[_idx] === ic) {
//       const _p = processValue(_l, _idx + 1, true, _fi);
//       if (!FileExist(_p)) {
//         throw new Error('文件不存在: ' + _p);
//       } else {
//         return MeowConfEx.Builder()
//           .DataFromFile(Path.IsAbsolute(_p) ? _p : Path.Join(Path.Dir(cp), _p))
//           .SetWarn(this.doWarn)
//           .Build().data;
//       }
//     }

//     while (_idx <= cs.length) {
//       let esc = false;
//       if (cs[_idx] === A_Tab) {
//         throw new Error('不允许使用Tab');
//       } else if (cs[_idx] === ec) {
//         esc = true;
//         _idx++;
//       }

//       if (_idx > cs.length) {
//         throw new Error('转义符后应接任意字符');
//       }

//       if (!inQ && cs[_idx] === A_Space) {
//         const _i = _idx;
//         _go(cs, A_Space, _fi);
//         if (_idx <= cs.length && cs[_idx] !== cc) {
//           Warn(`忽略了一条值的后续内容(${_l.substring(_i)})，因为没有在${q}内使用空格`, _idx, _l, cp);
//         }
//         break;
//       } else if (!esc && cs[_idx] === q) {
//         inQ = !inQ;
//       } else if (!esc && cs[_idx] === cc) {
//         if (inQ) {
//           Warn('错误的读取到注释符，考虑是否需要转义', _idx, _l, cp);
//           s += cs[_idx];
//         } else {
//           Warn('错误的读取到注释符，考虑是否正确闭合引号', _idx, _l, cp);
//           s += cs[_idx];
//         }
//       } else if (!_raw && cs[_idx] === rc && !esc) {
//         const _i = ++_idx;
//         _to(cs, rc, _fi, '未找到成对的引用符');
//         const _k = _l.substring(_i, _idx);

//         // if is func
//         if (/^\w+\(.*?\)$/.test(_k)) {
//           DCon(_parseFuncDef(_k), { name: 'fName', params: 'params' });
//           let vals = params.keys.map(v => (v[1] === fnc) ? _doRef(v.substring(2)) : v);

//           if (MeowConfEx.buildinFunc.Has(name)) {
//             s += MeowConfEx.buildinFunc.Get(name)(...vals);
//             _idx++;
//             continue;
//           } else if (_has(name)) {
//             s += _get(name)(...vals)();
//             _idx++;
//             continue;
//           } else {
//             throw new Error('未定义的函数');
//           }
//         }

//         const _v = _doRef(_k);
//         if (!IsPrimitive(_v)) {
//           Warn('引用复杂类型', _idx, _l, cp);
//           // 继续，看是否有注释
//           _to(_l, cc, _fi, '');
//           _fi[0] = _idx;
//           return _v;
//         }
//         s += _v;
//       } else {
//         s += cs[_idx];
//       }

//       if (_idx === cs.length && inQ) {
//         throw new Error('未正确闭合引号');
//       }
//       _idx++;
//     }

//     _fi[0] = _idx;
//     return s;

//     function _doRef(_k) {
//       if (_has(_k)) {
//         return _get(_k);
//       }
//       const re = /\[(.*?)\]$/;
//       if (re.test(_k)) {
//         _k = _k.substring(1, re.index);
//         let _v;
//         try {
//           _v = (_o = _get(_k))[RegExp.\$1];
//         } catch {
//           throw new Error('无效的引用: ' + RegExp.\$1);
//         }
//         if (!_v && TypeIsObj(_o)) {
//           throw new Error('无效的对象子项引用: ' + RegExp.\$1);
//         }
//       } else {
//         throw new Error('引用不存在的键或预设值: ' + _k);
//       }
//       return _v;
//     }
//   }

// }